package com.yuncheng.oaApi.lcService;

import org.springframework.stereotype.Component;


@Component(value = "OaqxjFlowService")
public class OaqxjOaFlowService extends OaFlowService {
//
//    public Result handleFlow(OaFlowVo oaFlowVo, OaJob nowJob, String jobId, String oaid, String submitType, String opinion) {
//
//        // 当前流程任务
//        if (StringUtils.isNotBlank(jobId)) {
//            nowJob = spcySqsxJobService.getById(jobId);
//        }
//
//        if (nowJob == null) {
//            return Result.error("当前流程任务不存在，请重试");
//        }
//
//
//        if (StringUtils.isBlank(oaid)) {
//            oaid = nowJob.getFpid();
//        }
//
//        if (StringUtils.isBlank(oaid)) {
//            throw new BusinessException("参数丢失，请联系管理员");
//        }
//
//
//        // 提交按钮
//        if (submitType.equals(CommonFlowConstant.SUBMIT_TYPE_SUBMIT)) {
//            if (nowJob == null) {
//                return Result.error("当前流程任务不存在");
//            }
//        }
//        CurrentUserVo currentUser = ThreadContextHelper.getCurrentUser();
//        if (currentUser == null) {
//            return Result.error("登录已失效，请重新登录");
//        }
//
//        //当前环节办理人名称以及时间
//        if (nowJob.getFhjmc().equals(OaqxjFlowConstant.HJMC_KSSP)) {
//            String timeStr = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
//
//            String name = currentUser.getName();
//            OaQxjsp byId = oaQxjspService.getById(oaid);
//            byId.setFksqm(name);
//            byId.setFksqmsj(timeStr);
//            oaQxjspService.updateById(byId);
//            //分管领导审批
//        } else if (nowJob.getFhjmc().equals(OaqxjFlowConstant.HJMC_RSSP)) {
//            String timeStr = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
//
//            String name = currentUser.getName();
//            OaQxjsp byId = oaQxjspService.getById(oaid);
//            byId.setFrsqm(name);
//            byId.setFrsqmsj(timeStr);
//            oaQxjspService.updateById(byId);
//
//        } else if (nowJob.getFhjmc().equals(OaqxjFlowConstant.HJMC_FGSP)) {
//            String timeStr = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
//
//            String name = currentUser.getName();
//            OaQxjsp byId = oaQxjspService.getById(oaid);
//            byId.setFfgqm(name);
//            byId.setFfgqmsj(timeStr);
//            oaQxjspService.updateById(byId);
//            int fts = byId.getFts();
//            //在分管审批环节，如果请假时间小与等于一天 ，就直接到请假确认，结束流程
//            //或者直接结束流程，但是现在没有反馈，所以用第一版，到请假确认然后在提交结束
//            if (fts <= 1 && submitType.equals(CommonFlowConstant.SUBMIT_TYPE_SUBMIT)) {
//                //当前流程id
//                oaFlowVo.setNextNode(OaqxjFlowConstant.HJMC_QJQR);
//            }
//
//        } else if (nowJob.getFhjmc().equals(OaqxjFlowConstant.HJMC_DWLDSP)) {
//            String timeStr = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
//            String name = currentUser.getName();
//            OaQxjsp byId = oaQxjspService.getById(oaid);
//            byId.setFzxqm(name);
//            byId.setFzxqmsj(timeStr);
//            oaQxjspService.updateById(byId);
//        }
//        // 流程环节处理
//        Result httpResult = handleNodeName(oaFlowVo, submitType, nowJob, oaid, opinion);
//        if (!httpResult.isSuccess()) {
//            return httpResult;
//        }
//        //最后一步状态标注流程结束
//        /**
//         * @Author: lhb
//         * @Description :  是最后一步流程 且是 提交 才会判断为流程结束   并在这里做年休假的处理
//         * @DateTime:
//         * @Params:
//         */
//        if (nowJob.getFhjmc().equals(OaqxjFlowConstant.HJMC_QJQR) && submitType.equals(CommonFlowConstant.SUBMIT_TYPE_SUBMIT)) {
//            //当前流程id
//            OaQxjsp oaQxjsp = oaQxjspService.getById(oaid);
//            oaQxjsp.setFlczt(CommonFlowConstant.FLOW_LCJS);
//            oaQxjspService.updateById(oaQxjsp);
//
//            //更新完成后在信息通知表里插入一条消息 表示未读
//            sysTzMessageService.endMessage(oaid,false,true,false);
//
//
//            String fqjlx = oaQxjsp.getFqjlx();
//            String fsfnnxq = oaQxjsp.getFsfnnxq();
//            String fuserid = oaQxjsp.getFuserid(); //请假人id
//            YcSysUser user = ycSysUserService.getById(fuserid);
//
//            int fts = oaQxjsp.getFts(); //请假天数
//            String fsfnnxq1 = oaQxjsp.getFsfnnxq();
//            int fnxjsyts = user.getFnxjsyts(); //年休假剩余天数
//            int fnxjzjts = user.getFnxjzjts(); //年休假转结天数
//
//
//            if (StringUtils.isBlank(fqjlx)) {
//                throw new BusinessException("无法获取当前流程请假类型，请联系管理员");
//            }
//            if (StringUtils.isBlank(fuserid)) {
//                throw new BusinessException("无法获取当前请假人id,请联系管理员");
//            }
//            if (fqjlx.equals(OaqxjFlowConstant.QXJ_NJ) || fsfnnxq1.equals(OaqxjFlowConstant.QXJ_YES)) {
//                //年休假剩余天数直接减  等于0为止
//                // 转结天数如果大于请假天数 那就直接减 如果小于赋值0
//                if (fnxjsyts > 0) {
//                    int newsyts = fnxjsyts - fts;
//                    if (fts >= fnxjzjts) {
//                        user.setFnxjzjts(0);
//                    } else {
//                        int newfnxjzjts = fnxjzjts - fts;
//                        user.setFnxjzjts(newfnxjzjts);
//                    }
//                    user.setFnxjsyts(newsyts);
//                }
//            }
//            ycSysUserService.updateById(user);
//        }
//        return Result.ok("操作成功");
//    }
//
//    public Result handleNodeName(OaFlowVo oaFlowVo, String submitType, OaJob job, String oaId, String opinion) {
//        HashMap<String, Object> map = oaFlowVo.getMap();
//        String dbrid = oaFlowVo.getDbrid();// 下环节待办人
//        String smgflag = oaFlowVo.getSmgflag(); // 短信发送标志
//        boolean isSubmit = true; // 是否提交流程
//        Result res = null;
//
//        // 保存按钮
//        if (submitType.equals(CommonFlowConstant.SUBMIT_TYPE_SAVE)) {
//            updateSqsxJbxx(map, oaId, job);
//        }
//
//        // 提交按钮
//        if (submitType.equals(CommonFlowConstant.SUBMIT_TYPE_SUBMIT)) {
//            updateSqsxJbxx(map, oaId, job);
//
//            // 流程任务id
//            String jobId = "";
//            if (job != null) {
//                jobId = job.getId();
//            }
//
//            String nextNode = "";
//            if (StringUtils.isNotBlank(oaFlowVo.getNextNode())) {
//                nextNode = oaFlowVo.getNextNode();
//            }
//
//            // 提交流程任务,待办人是否为空，指定待办人
//            if (isSubmit) {
//                if (StringUtils.isBlank(dbrid)) {
//                    // 提交-流程任务
//                    res = this.passJob(oaId, jobId, opinion, nextNode, "");
//                } else {
//                    // 提交-流程任务
//                    res = this.passJob(oaId, jobId, opinion, nextNode, dbrid);
//                }
//            }
//            if (!res.isSuccess()) {
//                return res;
//            } else {
//                OaJob nowJob = (OaJob) res.getResult();
//                // 接收返回的流程任务，如果返回的流程任务id不相等，发送短信
//                if (nowJob != null && !jobId.equals(nowJob.getId()) && StringUtils.isNotBlank(smgflag) && smgflag.equals("是")) {
//
//                }
//            }
//        }
//
//        return Result.ok("提交成功");
//    }
//
//    public Result updateSqsxJbxx(HashMap<String, Object> map, String oaid, OaJob job) {
//        OaQxjsp oldBasic = oaQxjspService.getById(oaid);
//        if (oldBasic == null) {
//            return Result.error("当前申请事项【" + oaid + "】不存在，请重试");
//        }
//        OaQxjsp basicUpdate = null;
//        basicUpdate = oldBasic;
//
//        // 修改
//        ConvertUtils.register(new DateConvert(), java.util.Date.class);
//        try {
//            BeanUtils.populate(basicUpdate, map);
//            oaQxjspService.updateById(basicUpdate);
//        } catch (IllegalAccessException e) {
//            log.error("出错-保存申请事项【非法访问异常】,{}", e.getMessage());
//        } catch (InvocationTargetException e) {
//            log.error("出错-保存申请事项【调用TargetException】,{}", e.getMessage());
//        }
//
//        String logContent = "基本信息修改: ";
//        Map<String, Object> basicMap = ObjectToMapUtils.objectToMap(oldBasic);
//        logContent += LogUtils.BeanModifyMsg(basicUpdate, basicMap);
//
//        if (job == null) {
//            spcyLogService.addLogs("null", logContent, oaid, CommonFlowConstant.LOGS_SYS_TYPE_XG, CommonFlowConstant.LOGS_SYS_TYPE_XG);
//        } else {
//            spcyLogService.addLogs(job.getFhjmc(), logContent, oaid, CommonFlowConstant.LOGS_SYS_TYPE_XG, CommonFlowConstant.LOGS_SYS_TYPE_XG);
//        }
//
//        return Result.ok("保存成功");
//    }
//
//
//    /**
//     * @Author:
//     * @Description: 撤回流程
//     * @DateTime:
//     * @Params:
//     */
//
//    public Result returnlgqsFlow(String jobid, String opinion) {
//        if (StringUtils.isBlank(jobid)) {
//            return Result.error("参数丢失，请联系管理员");
//        }
//        OaJob nowJob = spcySqsxJobService.getById(jobid);
//        if (nowJob == null) {
//            return Result.error("当前流程任务不存在，请刷新重试");
//        }
//        if (StringUtils.isNotBlank(nowJob.getFblzt()) && nowJob.getFblzt().equals(CommonFlowConstant.BLZT_YB)) {
//            return Result.error("当前环节【" + nowJob.getFhjmc() + "】已经办理，无法撤回");
//        }
//
//        String nowNode = nowJob.getFhjmc(); // 当前环节
//        String previousName = oaqxjFlowConstant.getPreviousName(nowNode); // 上环节名称
//
//        StringBuffer logNr = new StringBuffer("撤回流程：\n");
//
//        // 判断是否为第一个环节
//        if (nowNode.equals(previousName)) {
//            OaQxjsp sqsx = oaQxjspService.getById(nowJob.getFpid());
//            if (sqsx != null) {
//                sqsx.setFlczt("");
//                oaQxjspService.updateById(sqsx);
//            }
//            spcySqsxJobService.removeById(jobid);
//            logNr.append("环节名称").append("[").append(nowNode).append("]");
//
//        } else if (nowNode.equals(OaLgqsFlowConstant.HJMC_XJ)) {
//            // 上环节
//            String fsyhjid = nowJob.getFsyhjid();
//            if (StringUtils.isNotBlank(fsyhjid)) {
//                OaJob preJob = spcySqsxJobService.getById(fsyhjid);
//                if (preJob != null) {
//                    preJob.setFblzt(CommonFlowConstant.BLZT_DB);
//                    spcySqsxJobService.updateById(preJob);
//                }
//            }
//            spcySqsxJobService.removeById(jobid);
//            logNr.append("环节名称").append("[").append(nowNode).append("]");
//        }
//        if (StringUtils.isNotBlank(opinion)) {
//            logNr.append("\n").append("撤回意见").append("[").append(opinion).append("]。");
//        }
//        spcyLogService.addLogs(nowNode, logNr.toString(), nowJob.getFpid(), CommonFlowConstant.LOGS_SYS_TYPE_TH, CommonFlowConstant.LOGS_SYS_TYPE_TH);
//
//        return Result.ok("撤回成功");
//    }
//
//    /**
//     * @Author:
//     * @Description : 退回流程
//     * @DateTime:
//     * @Params:
//     */
//    public Result getReturnUpperFlowJob(String jobid, String opinion) {
//        if (StringUtils.isBlank(jobid)) {
//            return Result.error("当前流程任务id不能为空");
//        }
//        OaJob job = spcySqsxJobService.getById(jobid);
//        if (job == null) {
//            return Result.error("当前流程任务不存在");
//        }
//        // 办理状态 - 待办
//        if (StringUtils.isNotBlank(job.getFblzt()) && (job.getFblzt().equals(CommonFlowConstant.BLZT_DB) || job.getFblzt().equals(CommonFlowConstant.BLZT_TH))) {
//            // 待办-获取上一个环节id
//            String fsyhjid = job.getFsyhjid();
//            OaJob syhjJob = spcySqsxJobService.getById(fsyhjid);
//            if (syhjJob != null) {
//                syhjJob.setFthyj(opinion);
//
//                syhjJob.setFfssj(new Date());
//                syhjJob.setFblzt(CommonFlowConstant.BLZT_TH);
//                spcySqsxJobService.updateById(syhjJob);
//
//                spcySqsxJobService.removeById(jobid); // 删除当前流程任务待办
//            }
//        }
//        String logNr = "退回上一环节: ";
//        Map<String, Object> map = ObjectToMapUtils.objectToMap(job);
//        logNr += LogUtils.MapToStringMethod(map);
//        spcyLogService.addLogs(job.getFhjmc(), logNr, job.getFpid(), LogConstant.LOGS_SQSX_JOB, CommonFlowConstant.LOGS_SYS_TYPE_TH);
//        return Result.ok("success");
//    }
//
//
//    /**
//     * @Author:
//     * @Description : 退回指定环节
//     * @DateTime:
//     * @Params:
//     */
//    public Result getReturnUpperJob(String jobid, String opinion, String fhjmc) {
//        if (StringUtils.isBlank(jobid)) {
//            return Result.error("当前流程任务id不能为空");
//        }
//        OaJob job = spcySqsxJobService.getById(jobid);
//        if (job == null) {
//            return Result.error("当前流程任务不存在");
//        }
//        //获取上一个环节id
//        String fsyhjid = job.getFsyhjid();
//        OaJob syhjJob = spcySqsxJobService.getById(fsyhjid);
//        if (syhjJob != null) {
//            syhjJob.setFthyj(opinion);
//
//            syhjJob.setFfssj(new Date());
//            syhjJob.setFblzt(CommonFlowConstant.BLZT_TH);
//            spcySqsxJobService.updateById(syhjJob);
//
//            spcySqsxJobService.removeById(jobid); // 删除当前流程任务待办
//        }
//
//        String logNr = "退回上一环节: ";
//        Map<String, Object> map = ObjectToMapUtils.objectToMap(job);
//        logNr += LogUtils.MapToStringMethod(map);
//        spcyLogService.addLogs(job.getFhjmc(), logNr, job.getFpid(), LogConstant.LOGS_SQSX_JOB, CommonFlowConstant.LOGS_SYS_TYPE_TH);
//        return Result.ok("success");
//    }
//
//    /**
//     * 查询流程当前环节-上一环节
//     * * @param jobid 流程任务id
//     * * @param isZdhj 是否指定环节
//     * * @return
//     */
//    public List<Map<String, String>> getCurrentJobPrevious(String jobid, boolean isZdhj) {
//        if (StringUtils.isBlank(jobid)) {
//            throw new BusinessException("流程任务参数为空！");
//        }
//
//        OaJob currentJob = spcySqsxJobService.getById(jobid);
//        if (currentJob == null) {
//            throw new BusinessException("当前流程任务不存在！");
//        }
//
//        String fywflcode = "";
//        String fpid = currentJob.getFpid(); // 关联业务id
//        String flcmc = currentJob.getFlcmc(); // 所属流程
//        String currentNode = currentJob.getFhjmc(); // 当前环节
//
//        if (StringUtils.isBlank(flcmc)) {
//            fywflcode = oaqxjFlowConstant.getFywflcode();
//
//        } else {
//            if (flcmc.equals(oaqxjFlowConstant.getFlowName())) {
//                fywflcode = oaqxjFlowConstant.getFywflcode();
//            }
//        }
//
//        List<Map<String, String>> ybNodeList = new ArrayList<>(); // 退回环节数组
//        String previousNode = this.getPreviousNodeByYwflcode(fywflcode, currentNode); // 上一环节
//
//        // 指定环节
//        if (isZdhj) {
//            List<OaJob> preJobList = spcySqsxJobService.list(new LambdaQueryWrapper<OaJob>()
//                    .eq(OaJob::getFpid, fpid)
//                    .eq(OaJob::getFblzt, CommonFlowConstant.BLZT_YB)
//                    .eq(OaJob::getFlcmc, flcmc)
//                    .orderByAsc(OaJob::getFfssj));
//            if (CollectionUtils.isNotEmpty(preJobList)) {
//                for (OaJob job : preJobList) {
//
//                    // 判断是否存在一样的环节名称，存在跳出当次循环
//                    boolean isExistNode = false;
//                    if (CollectionUtils.isNotEmpty(ybNodeList)) {
//                        for (Map<String, String> disMap : ybNodeList) {
//                            if (disMap.get("fhjmc").equals(job.getFhjmc())) {
//                                isExistNode = true;
//                                break;
//                            }
//                        }
//                    }
//                    if (isExistNode) {
//                        continue;
//                    }
//                    Map<String, String> map = new HashMap<>();
//                    map.put("id", job.getId());
//                    map.put("fhjmc", job.getFhjmc());
//                    ybNodeList.add(map);
//                }
//            }
//        } else {
//            // 查询上一环节是否存在
//            List<OaJob> preJobList = spcySqsxJobService.list(new LambdaQueryWrapper<OaJob>()
//                    .eq(OaJob::getFpid, fpid)
//                    .eq(OaJob::getFhjmc, previousNode)
//                    .eq(OaJob::getFblzt, CommonFlowConstant.BLZT_YB)
//                    .eq(OaJob::getFlcmc, flcmc)
//                    .orderByDesc(OaJob::getFfssj));
//
//            if (CollectionUtils.isNotEmpty(preJobList)) {
//                Map<String, String> map = new HashMap<>();
//                map.put("id", preJobList.get(0).getId());
//                map.put("fhjmc", preJobList.get(0).getFhjmc());
//                ybNodeList.add(map);
//            }
//        }
//        return ybNodeList;
//    }
//
//    /**
//     * 退回流程 - 指定环节
//     */
//    public void returnZdJob(OaReturnVo oaReturnVo) {
//        CurrentUserVo currentUser = ThreadContextHelper.getCurrentUser();
//        if (currentUser == null) {
//            throw new BusinessException("登录已失效，请重新登录！");
//        }
//
//        if (StringUtils.isBlank(oaReturnVo.getJobid())) {
//            throw new BusinessException("流程任务参数为空！");
//        }
//
//        if (StringUtils.isBlank(oaReturnVo.getOpinion())) {
//            throw new BusinessException("请填写退回意见！");
//        }
//
//        if (StringUtils.isBlank(oaReturnVo.getShjid())) {
//            throw new BusinessException("请选择退回环节！");
//        }
//
//        // 当前环节
//        OaJob currentJob = spcySqsxJobService.getById(oaReturnVo.getJobid());
//        if (currentJob == null) {
//            throw new BusinessException("当前流程任务不存在！");
//        }
//
//        String sqsxid = currentJob.getFpid();
//        String oldfhjmc = currentJob.getFhjmc();
//
//
//        // 上一环节
//        OaJob previousJob = spcySqsxJobService.getById(oaReturnVo.getShjid());
//        if (currentJob == null) {
//            throw new BusinessException("当前流程任务不存在！");
//        }
//        String previousNode = previousJob.getFhjmc();
//
//        String bllx = "[" + oldfhjmc + "]" + CommonFlowConstant.BLLX_TH + "[" + previousNode + "]";
//        Result result = this.doJob(currentJob, currentUser, oaReturnVo.getOpinion(), bllx);
//        if (!result.isSuccess()) {
//            throw new BusinessException(result.getMessage());
//        }
//
//        /**
//         * 创建退回环节流程任务
//         */
//        OaJob newPreviousJob = new OaJob();
//        BeanUtil.copyProperties(previousJob, newPreviousJob);
//        newPreviousJob.setId(GetUuIdUtils.NotReplaceUuId());
//
//        if (StringUtils.isBlank(newPreviousJob.getFpid())) {
//            newPreviousJob.setFpid(sqsxid);
//        }
//
//
//        newPreviousJob.setFblzt(CommonFlowConstant.BLZT_TH);
//        newPreviousJob.setFthyj(oaReturnVo.getOpinion());
//        newPreviousJob.setFlcmc(OaqxjFlowConstant.LCMC_LIKE_OALC);
//        newPreviousJob.setFblyj("");
//        newPreviousJob.setFblr("");
//        newPreviousJob.setFblsj(null);
//        newPreviousJob.setFblbm("");
//        newPreviousJob.setFbllx(bllx);
//        newPreviousJob.setFfssj(new Date());
//        newPreviousJob.setFfsrid(currentUser.getId());
//        newPreviousJob.setFfsrmc(currentUser.getName());
//        spcySqsxJobService.save(newPreviousJob);
//        //处理主表数据
//        OaQxjsp oaQxjsp = oaQxjspService.getById(sqsxid);
//        if (previousNode.equals(OaqxjFlowConstant.HJMC_SQ)) {
//            oaQxjsp.setFksqm("");
//            oaQxjsp.setFksqmsj("");
//            oaQxjsp.setFksyj("");
//            oaQxjsp.setFrsqmsj("");
//            oaQxjsp.setFrsqm("");
//            oaQxjsp.setFrsyj("");
//            oaQxjsp.setFfgqmsj("");
//            oaQxjsp.setFfgqm("");
//            oaQxjsp.setFfgyj("");
//            oaQxjsp.setFzxqmsj("");
//            oaQxjsp.setFzxqm("");
//            oaQxjsp.setFzxyj("");
//            oaQxjsp.setFlczt(CommonFlowConstant.FLOW_LCZB);
//        } else if (previousNode.equals(OaqxjFlowConstant.HJMC_KSSP)) {
//            oaQxjsp.setFrsqmsj("");
//            oaQxjsp.setFrsqm("");
//            oaQxjsp.setFrsyj("");
//            oaQxjsp.setFfgqmsj("");
//            oaQxjsp.setFfgqm("");
//            oaQxjsp.setFfgyj("");
//            oaQxjsp.setFzxqmsj("");
//            oaQxjsp.setFzxqm("");
//            oaQxjsp.setFzxyj("");
//            oaQxjsp.setFlczt(CommonFlowConstant.FLOW_LCZB);
//        } else if (previousNode.equals(OaqxjFlowConstant.HJMC_RSSP)) {
//            oaQxjsp.setFfgqmsj("");
//            oaQxjsp.setFfgqm("");
//            oaQxjsp.setFfgyj("");
//            oaQxjsp.setFzxqmsj("");
//            oaQxjsp.setFzxqm("");
//            oaQxjsp.setFzxyj("");
//            oaQxjsp.setFlczt(CommonFlowConstant.FLOW_LCZB);
//        } else if (previousNode.equals(OaqxjFlowConstant.HJMC_FGSP)) {
//            oaQxjsp.setFzxqmsj("");
//            oaQxjsp.setFzxqm("");
//            oaQxjsp.setFzxyj("");
//            oaQxjsp.setFlczt(CommonFlowConstant.FLOW_LCZB);
//        } else {
//            oaQxjsp.setFlczt(CommonFlowConstant.FLOW_LCZB);
//        }
//        oaQxjspService.updateById(oaQxjsp);
//    }
//
//    /**
//     * 获取上一环节-通过业务分类编码
//     *
//     * @param ywflCode    业务分类编码
//     * @param currentNode 当前环节
//     * @return
//     */
//    private String getPreviousNodeByYwflcode(String ywflCode, String currentNode) {
//        String preNode = "";
//
//        if (ywflCode.equals(CommonFlowConstant.OA_LGQS)) {
//            preNode = oaqxjFlowConstant.getPreviousName(currentNode);
//        }
//
//        return preNode;
//    }
//
//
//    /**
//     * 获取当前流程任务相关信息
//     *
//     * @param jobid 流程任务id
//     */
//    public Map getJobConcernByJobId(String jobid) {
//        Map map = new HashMap();
//
//        // 当前流转记录
//        OaJob job = spcySqsxJobService.getById(jobid);
//        if (job == null) {
//            log.error("当前流程任务id为【{}】的流转记录不存在", jobid);
//            return map;
//        }
//        String oaid = job.getFpid();
//        if (org.apache.commons.lang3.StringUtils.isBlank(oaid)) {
//            log.error("当前流程任务id为【{}】的流转记录中的申请事项id为空", jobid);
//            return map;
//        }
//
//        // oaid事项基本信息
//        OaQxjsp sqsxBasic = oaQxjspService.getById(oaid);
//
//        // 流程任务流传记录
//        List<OaJob> jobList = this.getJobListByOaId(oaid);
//
////        // 申请事项相关文件记录
////        List<SpcySqsxWjjl> wjjlList = busService.getWjjlListBySqsxId(oaid);
//
//        // 申请事项的检查项目
////        List<SpcySqsxJcxm> jcxmList = getJcxmQxListBySqsxId(sqsxBasic);
//
//
//        // 获取下环节待办人
//        String nextNode = oaqxjFlowConstant.getNextNodeName(job.getFhjmc());
//        Map nextDbr = this.getNodeDbr(oaid, nextNode, "");
//        List<AgentVo> dbrListByMap = dbrService.getDbrListByMap(nextDbr);
//
//        map.put("sqsx", sqsxBasic); // 申请事项基本信息
//        map.put("job", job); // 当前流转记录
//        map.put("jobHistoryList", jobList); // 流程任务流传记录
////        map.put("wjjlList",wjjlList); // 申请事项-相关文件
//
//        map.put("nextNodeDbrList", dbrListByMap); // 下环节待办人list
//        map.put("nextNode", nextNode);
//
//        return map;
//    }
//
//    /**
//     * 获取oa-流转记录
//     */
//    public List<OaJob> getJobListByOaId(String oaid) {
//        LambdaQueryWrapper<OaJob> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.like(OaJob::getFlcmc, oaqxjFlowConstant.getFlowName());
//        queryWrapper.eq(OaJob::getFpid, oaid);
//        queryWrapper.orderByAsc(OaJob::getCreateTime);
//        queryWrapper.orderByAsc(OaJob::getFfssj);
//        List<OaJob> jobList = spcySqsxJobService.list(queryWrapper);
//
//        return jobList;
//    }
//
//
//    //初始化任务
//    public Result initJob(String oaId, CurrentUserVo currentUser) {
//        String nodeName = oaqxjFlowConstant.getFirstNode();
//        //需要校验是否已经初始化过
//        List<OaJob> list = spcySqsxJobService.list(new LambdaQueryWrapper<OaJob>()
//                .eq(OaJob::getFpid, oaId)
//                .eq(OaJob::getFhjmc, nodeName)
//                .eq(OaJob::getFlcmc, oaqxjFlowConstant.getFlowName())
//        );
//        if (list.size() > 0) {
//            return Result.ok(list.get(0));
//
//        }
//        return this.initJob(oaqxjFlowConstant, oaId, currentUser);
//    }
//
//    /**
//     * 提交当前环节的待办记录
//     *
//     * @param oaId    oa-id
//     * @param jobId   当前环节id
//     * @param opinion 办理意见
//     */
//    public Result passJob(String oaId, String jobId, String opinion, String nextNodeName, String nextNodeDbrIds) {
//        //处理业务表的逻辑
//        Result httpResult = this.passJob(oaqxjFlowConstant, oaId, jobId, opinion, nextNodeName, nextNodeDbrIds);
//        return httpResult;
//    }
//
//
//    /**
//     * @param job
//     * @param currentUser
//     */
//    private Result doJob(OaJob job, CurrentUserVo currentUser, String opinion) {
//        String blrId = "";
//        String blr = "";
//        if (currentUser != null) {
//            blrId = currentUser.getId();
//            blr = currentUser.getName();
//        }
//
//        if (CommonFlowConstant.BLZT_YB.equals(job.getFblzt())) {
//            return Result.error("当前任务已提交");
//        }
//        if (StringUtils.isBlank(job.getFdbrid())) {
//            return Result.error("当前任务未指定办理人");
//        }
//        if (!job.getFdbrid().contains(blrId)) {
//            return Result.error("当前登录用户无此任务的办理权限");
//        }
//        // 办理方式 竞争办理 、多人线性办理 、多人并行办理
//        String blfs = job.getFblfs();
//        if (StringUtils.isBlank(blfs) || blfs.equals(CommonFlowConstant.BLFS_DRJJ)) {
//            job.setFblr(blr);
//            job.setFblsj(new Date());
//            job.setFblyj(opinion);
//            job.setFblzt(CommonFlowConstant.BLZT_YB);
//            spcySqsxJobService.updateById(job);
//            return Result.ok(job);
//        } else if (blfs.equals(CommonFlowConstant.BLFS_DRXX) || blfs.equals(CommonFlowConstant.BLFS_DRBX)) {
//            //先根据多个人线性和多人并行的逻辑获得下一办理人
//            String nextBlrId = "";
//            String nextBlr = "";
//            if (blfs.equals(CommonFlowConstant.BLFS_DRXX)) {
//                String ydbrIds[] = job.getFydbrid().split(",");
//                String ydbrs[] = job.getFydbr().split(",");
//                for (int i = 0; i < ydbrIds.length; i++) {
//                    String dbrId = ydbrIds[i];
//                    //不考虑办理人id重复出现（一个人办多次）的情况
//                    if (dbrId.equals(blrId)) {
//                        if (i + 1 < ydbrIds.length) {
//                            nextBlrId = ydbrIds[i + 1];
//                            nextBlr = ydbrs[i + 1];
//                            break;
//                        }
//                    }
//                }
//            } else {
//                String dbrIds[] = job.getFdbrid().split(",");
//                String dbrs[] = job.getFdbr().split(",");
//                for (int i = 0; i < dbrIds.length; i++) {
//                    String dbrId = dbrIds[i];
//                    String dbr = dbrs[i];
//                    //不考虑办理人id重复出现（一个人办多次）的情况
//                    if (!dbrId.equals(blrId)) {
//                        nextBlrId = nextBlrId + (StringUtils.isBlank(nextBlrId) ? "" : ",") + dbrId;
//                        nextBlr = nextBlr + (StringUtils.isBlank(nextBlr) ? "" : ",") + dbr;
//                    }
//                }
//            }
//
//            //如果存在下一办理人 就继续待办，多人办理意见用@@分隔，办理时间、办理人、意见 用|分隔
//            job.setFblr(blr);
//            job.setFblsj(new Date());
//            String blyj = (job.getFblyj() == null ? "" : job.getFblyj()) + (StringUtils.isBlank(job.getFblyj()) ? "" : "@@") + DateConversionUtils.DateToString(new Date()) + "|" + blr + "|" + opinion;
//            job.setFblyj(blyj);
//            if (StringUtils.isBlank(nextBlrId)) {
//                job.setFblzt(CommonFlowConstant.BLZT_YB);
//            } else {
//                job.setFblzt(CommonFlowConstant.BLZT_DB);
//                job.setFdbrid(nextBlrId);
//                job.setFdbr(nextBlr);
//            }
//            spcySqsxJobService.updateById(job);
//            return Result.ok(job);
//        }
//        return Result.error("待办任务未指定办理方式");
//    }
//
//
//    /**
//     * 办理环节
//     *
//     * @param job         当前流程任务
//     * @param currentUser 当前用户
//     * @param opinion     意见
//     * @param returnNode  退回环节
//     */
//    private Result doJob(OaJob job, CurrentUserVo currentUser, String opinion, String returnNode) {
//        String blrId = "";
//        String blr = "";
//        String blbm = "";
//        if (currentUser != null) {
//            blrId = currentUser.getId();
//            blr = currentUser.getName();
//            blbm = currentUser.getOrgName();
//        }
//        if (job == null) {
//            return Result.error("当前流程任务不存在，请重试");
//        }
////        if(CommonFlowConstant.BLZT_YB.equals(job.getFblzt())){
////            return Result.error("当前任务已提交");
////        }
//        if (StringUtils.isBlank(job.getFdbrid())) {
//            return Result.error("当前任务未指定办理人");
//        }
////        if(!job.getFdbrid().contains(blrId)){
////            return Result.error("当前登录用户无此任务的办理权限");
////        }
//        // 办理方式 竞争办理 、多人线性办理 、多人并行办理
//        String blfs = job.getFblfs();
//        if (StringUtils.isBlank(blfs) || blfs.equals(CommonFlowConstant.BLFS_DRJJ)) {
//            job.setFblr(blr);
//            job.setFblsj(new Date());
//            job.setFblyj(opinion);
//            job.setFblzt(CommonFlowConstant.BLZT_YB);
//            if (StringUtils.isBlank(returnNode)) {
//                job.setFbllx(CommonFlowConstant.BLLX_BL);
//            } else {
//                job.setFbllx(returnNode);
//            }
//            job.setFblbm(blbm);
//
//            // 审评查验流程 计算 办理天数、是否超时
//            /*if (StringUtils.isNotBlank(job.getFlcmc()) && job.getFlcmc().contains(YpscFlowConstant.LCMC_LIKE_SPCYLC)) {
//                job.setFsyts(flowJobBlsxService.jsTwoDateBetweenDays(job.getFksyts(),job.getFpid(),job.getFfssj(), job.getFblsj(), job.getFztkssj(),job.getFztjssj())); // 使用天数
//                job.setFsfcs(flowJobBlsxService.isDateBetweenSfcs(job.getFsyts(), job.getFcnts())); // 办理是否超时
//            }*/
//
//            spcySqsxJobService.updateById(job);
//            return Result.ok(job);
//        } else if (blfs.equals(CommonFlowConstant.BLFS_DRXX) || blfs.equals(CommonFlowConstant.BLFS_DRBX)) {
//            //先根据多个人线性和多人并行的逻辑获得下一办理人
//            String nextBlrId = "";
//            String nextBlr = "";
//            if (blfs.equals(CommonFlowConstant.BLFS_DRXX)) {
//                String ydbrIds[] = job.getFydbrid().split(",");
//                String ydbrs[] = job.getFydbr().split(",");
//                for (int i = 0; i < ydbrIds.length; i++) {
//                    String dbrId = ydbrIds[i];
//                    //不考虑办理人id重复出现（一个人办多次）的情况
//                    if (dbrId.equals(blrId)) {
//                        if (i + 1 < ydbrIds.length) {
//                            nextBlrId = ydbrIds[i + 1];
//                            nextBlr = ydbrs[i + 1];
//                            break;
//                        }
//                    }
//                }
//            } else {
//                String dbrIds[] = job.getFdbrid().split(",");
//                String dbrs[] = job.getFdbr().split(",");
//                for (int i = 0; i < dbrIds.length; i++) {
//                    String dbrId = dbrIds[i];
//                    String dbr = dbrs[i];
//                    //不考虑办理人id重复出现（一个人办多次）的情况
//                    if (!dbrId.equals(blrId)) {
//                        nextBlrId = nextBlrId + (StringUtils.isBlank(nextBlrId) ? "" : ",") + dbrId;
//                        nextBlr = nextBlr + (StringUtils.isBlank(nextBlr) ? "" : ",") + dbr;
//                    }
//                }
//            }
//
//            //如果存在下一办理人 就继续待办，多人办理意见用@@分隔，办理时间、办理人、意见 用|分隔
//            job.setFblr(blr);
//            job.setFblsj(new Date());
//            String blyj = (job.getFblyj() == null ? "" : job.getFblyj()) + (StringUtils.isBlank(job.getFblyj()) ? "" : "@@") + DateConversionUtils.DateToString(new Date()) + "|" + blr + "|" + opinion;
//            job.setFblyj(blyj);
//            if (StringUtils.isBlank(nextBlrId)) {
//                job.setFblzt(CommonFlowConstant.BLZT_YB);
//                if (StringUtils.isBlank(returnNode)) {
//                    job.setFbllx(CommonFlowConstant.BLLX_BL);
//                } else {
//                    job.setFbllx(returnNode);
//                }
//                job.setFblbm(blbm);
//            } else {
//                job.setFblzt(CommonFlowConstant.BLZT_DB);
//                job.setFdbrid(nextBlrId);
//                job.setFdbr(nextBlr);
//            }
//            spcySqsxJobService.updateById(job);
//            return Result.ok(job);
//        }
//        return Result.error("待办任务未指定办理方式");
//    }
//
//
//    /**
//     * @param oaId
//     * @param currentJob
//     * @param currentUser
//     * @param nextNodeName
//     * @param nextNodeDbrIds
//     * @return
//     */
//    public Result createNextJob(String oaId, OaJob currentJob, CurrentUserVo currentUser, String nextNodeName, String nextNodeDbrIds) {
//        if (currentJob != null) {
//            nextNodeName = getNextNodeName(currentJob.getFhjmc(), nextNodeName);
//        } else {
//            if (StringUtils.isBlank(nextNodeName)) {
//                return Result.error("下环节不能为空");
//            }
//        }
//        if (nextNodeName.equals(OaLgqsFlowConstant.HJMC_LCJS)) {
//            OaJob job = new OaJob();
//
//            return Result.ok("操作成功");
//        }
//        Map map = this.getNodeDbr(oaId, nextNodeName, nextNodeDbrIds);
//        nextNodeDbrIds = map.get("dbrId").toString();
//        String nextNodeDbrs = map.get("dbr").toString();
//        if (StringUtils.isBlank(nextNodeDbrIds)) {
//            return Result.error("获取不到下一环节待办人");
//        }
//        OaJob job = new OaJob();
//        job.setId(GetUuIdUtils.generateUuid());
//        if (currentJob != null) {
//            job.setFsyhjid(currentJob.getId());
//        }
//        job.setFpid(oaId);
//        job.setFhjmc(nextNodeName);
//        if (currentUser != null) {
//            job.setFfsrid(currentUser.getId());
//            job.setFfsrmc(currentUser.getName());
//        }
//        job.setFfssj(new Date());
//
//        job.setFdbrid(nextNodeDbrIds);
//        job.setFdbr(nextNodeDbrs);
//        job.setFydbrid(nextNodeDbrIds);
//        job.setFydbr(nextNodeDbrs);
//
//        // job.setFblfs(YpzcFlowConstant.getBlfs(nextNodeName));
//        job.setFblzt(CommonFlowConstant.BLZT_DB);
//        spcySqsxJobService.save(job);
//        return Result.ok(job);
//    }
//
//
//    /**
//     * @param:
//     * @Description: 创建第一个环节
//     * @auther: lhb
//     * @date: 2023/9/9 18:09
//     */
//    public Result createSqJob(String jobid, String oaId, String opinion) {
//        OaJob byId = spcySqsxJobService.getById(jobid);
//        CurrentUserVo currentUser = ThreadContextHelper.getCurrentUser();
//
//        String old = byId.getFhjmc();
//        String fhjmc = OaLgqsFlowConstant.HJMC_QJSQ;
//        String fpid = oaId;
//        LambdaQueryWrapper<OaJob> wrapper = new LambdaQueryWrapper<>();
//        wrapper.eq(OaJob::getFhjmc, fhjmc);
//        wrapper.eq(OaJob::getFpid, fpid);
//        wrapper.orderByDesc(OaJob::getFfssj);
//        wrapper.last("LIMIT 1");
//        List<OaJob> previousJob = spcySqsxJobService.list(new LambdaQueryWrapper<OaJob>()
//                .eq(OaJob::getFpid, fpid)
//                .eq(OaJob::getFhjmc, fhjmc));
////        System.out.println(previousJob);
//
//        String fdbr = previousJob.get(0).getFdbr();
//        String fdbrid = previousJob.get(0).getFdbrid();
//
//
//        /**
//         * 创建退回环节流程任务
//         */
//        OaJob newPreviousJob = new OaJob();
//
//        newPreviousJob.setId(GetUuIdUtils.NotReplaceUuId());
//        if (StringUtils.isBlank(newPreviousJob.getFpid())) {
//            newPreviousJob.setFpid(oaId);
//        }
//        newPreviousJob.setFdbr(fdbr);
//        newPreviousJob.setFdbrid(fdbrid);
//
//        newPreviousJob.setFlcmc(OaqxjFlowConstant.LCMC_LIKE_OALC);
//        newPreviousJob.setFhjmc(OaLgqsFlowConstant.HJMC_QJSQ);
//        newPreviousJob.setFthyj(opinion);
//        newPreviousJob.setFbllx(CommonFlowConstant.BLLX_DB);
//        newPreviousJob.setFblzt(CommonFlowConstant.BLZT_TH);
//        newPreviousJob.setFblyj("");
//        newPreviousJob.setFblr("");
//        newPreviousJob.setFblsj(null);
//        newPreviousJob.setFblbm("");
//        newPreviousJob.setFbllx("[" + old + "]" + "退回" + "[" + OaqxjFlowConstant.HJMC_SQ + "]");
//        newPreviousJob.setFfssj(new Date());
//        newPreviousJob.setFfsrid(currentUser.getId());
//        newPreviousJob.setFfsrmc(currentUser.getName());
//        newPreviousJob.setFsyhjid("");
//        newPreviousJob.setFblbm(currentUser.getDeptName());
//        newPreviousJob.setFblfs(CommonFlowConstant.BLFS_DRJJ);
//        newPreviousJob.setFthyj(opinion);
//        newPreviousJob.setFlcmc(OaqxjFlowConstant.LCMC_LIKE_OALC);
//
//        spcySqsxJobService.save(newPreviousJob);
//
//        return Result.ok(newPreviousJob);
//
//
//    }
//
//    /**
//     * @param job
//     * @param
//     */
//    public Result doJobs(String job, String opinion) {
//        OaJob byId = spcySqsxJobService.getById(job);
//        CurrentUserVo currentUser = ThreadContextHelper.getCurrentUser();
//        String blrId = "";
//        String blr = "";
//        if (currentUser != null) {
//            blrId = currentUser.getId();
//            blr = currentUser.getName();
//        }
//        if (job == null) {
//            return Result.error("当前流程任务不存在，请重试");
//        }
//        if (CommonFlowConstant.BLZT_YB.equals(byId.getFblzt())) {
//            return Result.error("当前任务已提交");
//        }
////        if(StringUtils.isBlank(job.getFdbrid())){
////            return Result.error("当前任务未指定办理人");
////        }
//        if (!byId.getFdbrid().contains(blrId)) {
//            return Result.error("当前登录用户无此任务的办理权限");
//        }
//        // 办理方式  、多人竞争办理
//        String blfs = byId.getFblfs();
//        if (StringUtils.isBlank(blfs) || blfs.equals(CommonFlowConstant.BLFS_DRJJ)) {
//            byId.setFblr(blr);
//            byId.setFblsj(new Date());
//            byId.setFblyj(opinion);
//            byId.setFblzt(CommonFlowConstant.BLZT_YB);
//            spcySqsxJobService.updateById(byId);
//            return Result.ok(job);
//        } else if (blfs.equals(CommonFlowConstant.BLFS_DRXX) || blfs.equals(CommonFlowConstant.BLFS_DRBX)) {
//            //先根据多个人线性和多人并行的逻辑获得下一办理人
//            String nextBlrId = "";
//            String nextBlr = "";
//            if (blfs.equals(CommonFlowConstant.BLFS_DRXX)) {
//                String ydbrIds[] = byId.getFydbrid().split(",");
//                String ydbrs[] = byId.getFydbr().split(",");
//                for (int i = 0; i < ydbrIds.length; i++) {
//                    String dbrId = ydbrIds[i];
//                    //不考虑办理人id重复出现（一个人办多次）的情况
//                    if (dbrId.equals(blrId)) {
//                        if (i + 1 < ydbrIds.length) {
//                            nextBlrId = ydbrIds[i + 1];
//                            nextBlr = ydbrs[i + 1];
//                            break;
//                        }
//                    }
//                }
//            } else {
//                String dbrIds[] = byId.getFdbrid().split(",");
//                String dbrs[] = byId.getFdbr().split(",");
//                for (int i = 0; i < dbrIds.length; i++) {
//                    String dbrId = dbrIds[i];
//                    String dbr = dbrs[i];
//                    //不考虑办理人id重复出现（一个人办多次）的情况
//                    if (!dbrId.equals(blrId)) {
//                        nextBlrId = nextBlrId + (StringUtils.isBlank(nextBlrId) ? "" : ",") + dbrId;
//                        nextBlr = nextBlr + (StringUtils.isBlank(nextBlr) ? "" : ",") + dbr;
//                    }
//                }
//            }
//
//            //如果存在下一办理人 就继续待办，多人办理意见用@@分隔，办理时间、办理人、意见 用|分隔
//            byId.setFblr(blr);
//            byId.setFblsj(new Date());
//            String blyj = (byId.getFblyj() == null ? "" : byId.getFblyj()) + (StringUtils.isBlank(byId.getFblyj()) ? "" : "@@") + DateConversionUtils.DateToString(new Date()) + "|" + blr + "|" + opinion;
//            byId.setFblyj(blyj);
//            if (StringUtils.isBlank(nextBlrId)) {
//                byId.setFblzt(CommonFlowConstant.BLZT_YB);
//            } else {
//                byId.setFblzt(CommonFlowConstant.BLZT_DB);
//                byId.setFdbrid(nextBlrId);
//                byId.setFdbr(nextBlr);
//            }
//            spcySqsxJobService.updateById(byId);
//            return Result.ok(job);
//        }
//        return Result.error("待办任务未指定办理方式");
//    }
//
//    /**
//     * @param currentNodeName 可为空(如果为空，nextNodeName不为空)
//     * @param nextNodeName    可为空(如果为空，currentNodename不为空)
//     * @return
//     */
//    private String getNextNodeName(String currentNodeName, String nextNodeName) {
//        if (StringUtils.isNotBlank(nextNodeName)) {
//            return nextNodeName;
//        } else {
//            return oaqxjFlowConstant.getNextNodeName(currentNodeName);
//        }
//    }
//
//    // 获取当前环节待办人
//    public Map getNodeDbr(String oaid, String nodeName, String dbrIds) {
//        Map map = new HashMap();
//        String dbrId = "";
//        String dbr = "";
//        if (StringUtils.isNotBlank(dbrIds)) {
//            dbr = getDbrsByIds(dbrIds);
//            dbrId = dbrIds;
//        } else {
//            String deptName = "";
//            // 请假申请
//            if (nodeName.equals(OaqxjFlowConstant.HJMC_SQ)) {
//                // 本人提交
//                CurrentUserVo user = ThreadContextHelper.getCurrentUser(); //当前用户信息
//                if (user == null) {
//                    throw new BusinessException("没有登录信息");
//                }
//                String id = user.getId();
//                String name = user.getName();
//                dbrId = id;
//                dbr = name;
//            }
//            // 科室审批
//            if (nodeName.equals(OaqxjFlowConstant.HJMC_KSSP)) {
//                // 科室负责人
//                OaQxjsp oaids = oaQxjspService.getById(oaid);
//                String fuserid = oaids.getFuserid();
//                YcSysUser user = ycSysUserService.getById(fuserid);
//                String orgName = user.getOrgName();
//
//                if (StringUtils.isBlank(orgName)) {
//                    throw new BusinessException("当前用户没有部门，请完善个人信息部门栏");
//                }
//                Map kzMap =dbrService.getKsfzrByDeptName(orgName);
//                dbrId = kzMap.get("dbrId").toString();
//                dbr = kzMap.get("dbr").toString();
//            }
//            //人事审批
//            if (nodeName.equals(OaqxjFlowConstant.HJMC_RSSP)) {
//                //请休假负责人办理 黄慧君
//                Map kzMap =dbrService.getBgsLgFzrByDeptName();
//                dbrId = kzMap.get("dbrId").toString();
//                dbr = kzMap.get("dbr").toString();
//            }
//            // 分管审批
//            if (nodeName.equals(OaqxjFlowConstant.HJMC_FGSP)) {
//                // 分管领导
//                Map kzMap = null;
//                OaQxjsp oaids = oaQxjspService.getById(oaid);
//                String fuserid = oaids.getFuserid();
//                YcSysUser user = ycSysUserService.getById(fuserid);
//                String orgName = user.getOrgName();
//
//                if (StringUtils.isBlank(orgName)) {
//                    throw new BusinessException("当前用户没有部门，请完善个人信息部门栏");
//                }
//                //如果填报部门是中心副主任 则是待办人是中心主任
//                if (orgName.contains(CommonFlowConstant.ORG_NAME_ZXFZR)) {
//                    kzMap = dbrService.getZxld();
//
//                } else {
//                    kzMap = dbrService.getKsFgldByDeptName(orgName);
//                }
//                dbrId = kzMap.get("dbrId").toString();
//                dbr = kzMap.get("dbr").toString();
//            }
//
//            // 单位领导审批
//            if (nodeName.equals(OaqxjFlowConstant.HJMC_DWLDSP)) {
//                //中心领导确认
//                Map kzMap = dbrService.getZxld();
//                dbrId = kzMap.get("dbrId").toString();
//                dbr = kzMap.get("dbr").toString();
//            }
//            //请假确认 如果是年假这个环节提交后扣除，如果是其他假 则确认是否请
//            if (nodeName.equals(OaqxjFlowConstant.HJMC_QJQR)) {
//                //黄慧君确认
//                Map kzMap = dbrService.getBgsLgFzrByDeptName();
//                dbrId = kzMap.get("dbrId").toString();
//                dbr = kzMap.get("dbr").toString();
//            }
//        }
//
//        map.put("dbrId", dbrId);
//        map.put("dbr", dbr);
//        return map;
//    }
//
//    // 获取当前环节待办人
//    public Map getNodeDbr(String nodeName, String dbrIds) {
//        return this.getNodeDbr(null, nodeName, dbrIds);
//    }
//
//    // 根据待办人id，获取名称拼接起来
//    private String getDbrsByIds(String dbrIds) {
//        //把待办人按id查出来  把名字拼起来
//        String dbr = "";
//        List<String> dbrIdsList = Arrays.asList(dbrIds.split(","));
//        List<YcSysUser> sysUserList = new ArrayList<>();
//        if (CollectionUtils.isNotEmpty(dbrIdsList)) {
//            sysUserList = ycSysUserService.listByIds(dbrIdsList);
//        }
//
//        if (CollectionUtils.isNotEmpty(sysUserList)) {
//            for (YcSysUser user : sysUserList) {
//                dbr += user.getRealname() + ",";
//            }
//        }
//
//        return dbr;
//    }
//
////    // 办公室考勤负责人
////    public Map getBgsLgFzrByDeptName() {
////        Map map = new HashMap();
////        String dbrId = "";
////        String dbr = "";
////        List<GetKsKz> ksKzObject = new ArrayList<>();
////        ksKzObject = ycSysUserService.getKsKzObject(CommonFlowConstant.BGS_SP_FLOW, CommonFlowConstant.ROLE_NAME_BGSLGFZR);
////        if (CollectionUtils.isNotEmpty(ksKzObject)) {
////            for (GetKsKz ksKz : ksKzObject) {
////                dbrId += ksKz.getId() + ",";
////                dbr += ksKz.getRealname() + ",";
////            }
////        } else {
////            throw new BusinessException("办公室考勤负责人不存在，请联系管理员");
////        }
////
////        map.put("dbrId", dbrId);
////        map.put("dbr", dbr);
////        return map;
////    }
////
////    // 对应科室的 科室负责人
////    public Map getKsfzrByDeptName(String deptName) {
////        Map map = new HashMap();
////        String dbrId = "";
////        String dbr = "";
////        List<GetKsKz> ksKzObject = new ArrayList<>();
////        ksKzObject = ycSysUserService.getKsKzObject(deptName, CommonFlowConstant.ROLE_NAME_KZ);
////        if (CollectionUtils.isNotEmpty(ksKzObject)) {
////            for (GetKsKz ksKz : ksKzObject) {
////                dbrId += ksKz.getId() + ",";
////                dbr += ksKz.getRealname() + ",";
////            }
////        }
////
////        map.put("dbrId", dbrId);
////        map.put("dbr", dbr);
////        return map;
////    }
////
////
////    // 获取对应科室的 分管领导
////    public Map getKsFgldByDeptName(String deptName) {
////        Map map = new HashMap();
////        String dbrId = "";
////        String dbr = "";
////
////        YcSysUser fgldUserBydept = sysUserFgldService.getFgldUserBydept(deptName);
////        if (fgldUserBydept != null) {
////            dbrId = fgldUserBydept.getId();
////            dbr = fgldUserBydept.getRealname();
////        }
////
////        map.put("dbrId", dbrId);
////        map.put("dbr", dbr);
////        return map;
////    }
////
////    public Map getZxld() {
////        Map map = new HashMap();
////        String dbrId = "";
////        String dbr = "";
////        // 中心主任
////        List<YcSysUser> zxzrList = ycSysUserService.list(new LambdaQueryWrapper<YcSysUser>()
////                .eq(YcSysUser::getOrgName, CommonFlowConstant.ORG_NAME_ZXZR));
////        if (CollectionUtils.isNotEmpty(zxzrList)) {
////            dbrId = zxzrList.get(0).getId();
////            dbr = zxzrList.get(0).getRealname();
////        }
////
////        map.put("dbrId", dbrId);
////        map.put("dbr", dbr);
////        return map;
////    }
////
////
////    /**
////     * 将待办人map转为List
////     *
////     * @param map 待办人map
////     */
////    public List<AgentVo> getDbrListByMap(Map map) {
////        String dbrids = map.get("dbrId").toString(); // 待办人id
////        String dbrs = map.get("dbr").toString(); // 待办人
////
////        List<AgentVo> agentList = new ArrayList<>();
////
////        if (org.apache.commons.lang3.StringUtils.isNotBlank(dbrids)) {
////            String agentIds[] = dbrids.split(",");
////            String agentNames[] = dbrs.split(",");
////
////            for (int i = 0; i < agentIds.length; i++) {
////                AgentVo agentVo = new AgentVo();
////                agentVo.setDbrid(agentIds[i]);
////                agentVo.setDbr(agentNames[i]);
////                agentList.add(agentVo);
////            }
////        }
////        return agentList;
////    }
////
////
////    // 对应科室的 科室负责人的id
////    public String getKsfzrByDeptNames(String deptName) {
////        Map map = new HashMap();
////        String dbrId = "";
////        List<GetKsKz> ksKzObject = new ArrayList<>();
////        ksKzObject = ycSysUserService.getKsKzObject(deptName, CommonFlowConstant.ROLE_NAME_KZ);
////        if (CollectionUtils.isNotEmpty(ksKzObject)) {
////            for (GetKsKz ksKz : ksKzObject) {
////                dbrId += ksKz.getId() + ",";
////            }
////        }
////        String dbrids = dbrId;
////        if (StringUtils.isNotBlank(dbrids)) {
////            return dbrId;
////        }
////        return ("没有找到待办人id");
////    }
////
////    // 对应科室的 科室负责人的id
////    public Map getKsfzrByDeptid(String deptName) {
////        Map map = new HashMap();
////        String dbrId = "";
////        String dbr = "";
////        List<GetKsKz> ksKzObject = new ArrayList<>();
////        ksKzObject = ycSysUserService.getKsKzObject(deptName, CommonFlowConstant.ROLE_NAME_KZ);
////        if (CollectionUtils.isNotEmpty(ksKzObject)) {
////            for (GetKsKz ksKz : ksKzObject) {
////                dbrId += ksKz.getId() + ",";
////            }
////        }
////        map.put("dbrId", dbrId);
////
////        return map;
////    }
////
////    //判断当前用户是否是科室负责人
////    public boolean brksfzr() {
////        boolean notBlank = Boolean.parseBoolean(null);
////        CurrentUserVo currentUser = ThreadContextHelper.getCurrentUser();
////        String nowid = currentUser.getId();
////        Map ksfzrByDeptName = getKsfzrByDeptid(currentUser.getOrgName());
////        if (currentUser != null) {
////            for (Object value : ksfzrByDeptName.values()) {
////                String valuesplit = String.join(",", (CharSequence) value);
////                int i = valuesplit.lastIndexOf(",");
////                String substring = valuesplit.substring(0, i);
////
////                notBlank = nowid.equals(substring);
////            }
////            return notBlank;
////        } else {
////            return false;
////        }
////    }
//
//
//    /**
//     * @param:
//     * @Description: 判断请假天数后是否有调休日
//     * @auther: lhb
//     * @date: 2023/9/14 10:46
//     */
//    //提交的情况下如果年休假在节假日前后，则将用户表字段 本年度是否与节假日连休为 赋值为是 、每年在年休假效期结束时间 后一个月更新/或在年休假效期结束时间后一天更新
//    //判断请假时间的后一天是否是调休
//    public boolean sflx(String oaid, int ts) throws ParseException {
//        OaQxjsp byId = oaQxjspService.getById(oaid);
//        String fqjkssj = byId.getFqjkssj();
//        //转化为data类型
//        String format = "yyyy-MM-dd";
//        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
//        if (StringUtils.isBlank(fqjkssj)){
//            throw new BusinessException("获取不到请假开始日期，请联系管理员");
//        }
//        Date qjkssj = dateFormat.parse(fqjkssj);
//        long qjkssjTime = qjkssj.getTime();
//        //开始时间不可能在调休的时候请假，所以现在默认是在调休的前一天请假，然后和调休一起，之后在与办公室对接，如果与调休连休需要知道提前几天请假
//        List<Date> txDateList = new ArrayList<>();
//        List<SpcyRsJjrk> txList = spcyRsJjrkService.list(new LambdaQueryWrapper<SpcyRsJjrk>()
//                .like(SpcyRsJjrk::getFjjrlx, CommonFlowConstant.JJRK_LX_TX)
//                .orderByAsc(SpcyRsJjrk::getFjjrsj));
//        if (CollectionUtils.isNotEmpty(txList)) {
//            txDateList = txList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
//        }
//        //拿到请假几天，然后循环几次，看循环到的最后的日期是不是调休
//        for (int i = 0; i <= ts; i++) {
//            qjkssjTime += 86400000;
//        }
//        Date startDate = new Date(qjkssjTime); // 使用毫秒数创建Date对象
//        boolean tx = WorkDateUtils.isExists(startDate, txDateList);
//        return tx;
//    }
//
////    //更新是否调休
////    public Result updatelxzt(String oaid, int ts) throws ParseException {
////        OaQxjsp byId = oaQxjspService.getById(oaid);
////        if (sflx(oaid, ts)) {
////            //相等返回true  当前日期，在调休列表中  则将用户表字段 本年度是否与节假日连休为 赋值为是
////            String fuserid = byId.getFuserid();
////            if (StringUtils.isBlank(fuserid)) {
////                return Result.error("查询不到本流程的申请用户id，请联系管理员");
////            }
////            YcSysUser user = ycSysUserService.getById(fuserid);
////            user.setFsfyjjrlx(OaqxjFlowConstant.QXJ_YES);
////            ycSysUserService.updateById(user);
////        } else {
////            // 不相等返回false  当前日期，不在调休日期列表中
////            String fuserid = byId.getFuserid();
////            if (StringUtils.isBlank(fuserid)) {
////                return Result.error("查询不到本流程的申请用户id，请联系管理员");
////            }
////            YcSysUser user = ycSysUserService.getById(fuserid);
////            user.setFsfyjjrlx(OaqxjFlowConstant.QXJ_NO);
////            ycSysUserService.updateById(user);
////
////        }
////        return Result.ok("更新成功");
////    }
//
//
//    //在提交流程的时候，如果请休假类型为年休假且为流程在办的时候，则只能有一条数据
//    public boolean onenxj(String fuserid) {
//        List<OaQxjsp> list = oaQxjspService.list(new LambdaQueryWrapper<OaQxjsp>().eq(OaQxjsp::getFqjlx, OaqxjFlowConstant.QXJ_NJ)
//                .eq(OaQxjsp::getFuserid, fuserid)
//                .eq(OaQxjsp::getFlczt, CommonFlowConstant.FLOW_LCZB));
//        if (list.size() > 1) {
//            return false; //如果大于1那就是不止有一条数据 ，其实还可以说 流程在办且为年假的请假记录只能有一条
//        } else {
//            return true;
//        }
//    }
//
//    //年度信息 直接拿
//    public Result getndxx() {
//        CurrentUserVo currentUser = ThreadContextHelper.getCurrentUser();
//        if (StringUtils.isBlank(currentUser.getId())) {
//            return Result.error("当前登录已失效，请重新登录");
//        }
//        String id = currentUser.getId();
//
//        //年度信息
//        Map map = new HashMap(); // 结果集 map
//        List<YcSysUser> list = ycSysUserService.list(new LambdaQueryWrapper<YcSysUser>().eq(YcSysUser::getId, id));
//        YcSysUser ycSysUser = list.get(0);
//        int fnxjkxts = ycSysUser.getFnxjyxts(); //可休天数 是不变的。计算公式：工龄休假天数+上年转结
//        int fnxjsyts = ycSysUser.getFnxjsyts(); //剩余天数
//        int fnxjzjts = ycSysUser.getFnxjzjts(); //转结天数
//        int fnxjyxts = fnxjkxts - fnxjsyts; //年休假已休天数 = 年休假可休天数 - 年休假剩余天数
//
//
//        //        String ndxxmsg = "本年度可休年假：" + fnxjkxts + "天，" + "已休：" + fnxjyxts + "天，" + "剩余：" + fnxjsyts + "天";
//        map.put("fnxjkxts", fnxjkxts);
//        map.put("fnxjyxts", fnxjyxts);
//        map.put("fnxjsyts", fnxjsyts);
//
//
//        return Result.ok(map);
//    }
//
//    /**
//     * @param: qxlx 请假类型，  ts 天数， njdbj 是否拿年假抵病假
//     * @Description: 根据休假类型 获得请假信息
//     * @auther: lhb
//     * @date: 2023/9/15 9:12
//     */
//    public Result getqjxx(String qxlx, Integer ts, String njdbj) {
//        CurrentUserVo currentUser = ThreadContextHelper.getCurrentUser();
//        YcSysUser user = ycSysUserService.getById(currentUser.getId());
//
//        if (StringUtils.isNotBlank(qxlx)) {
//            if (qxlx.equals(OaqxjFlowConstant.QXJ_NJ)) {
//                if (user.getFnxjsyts() == 0) {
//                    return Result.ok("您本年度年假已休完，不能再申请年假,如有疑问请联系人事处！");
//                }
//            }
//            if (qxlx.equals(OaqxjFlowConstant.QXJ_SJ)) {
//                return Result.ok("");
//            }
//            if (qxlx.equals(OaqxjFlowConstant.QXJ_BJ)) {
//                //病假可以拿年休假相抵
//                if (njdbj.equals(OaqxjFlowConstant.QXJ_YES)) {
//                    if (user.getFnxjsyts() > 0) {
//                        return Result.ok("优先扣除年假" + ts + "天，实情病假0天。");
//                    } else {
//                        return Result.ok("优先扣除年假0天，" + "实情病假" + ts + "天。");
//                    }
//                } else {
//                    return Result.ok("请病假3天以上的需要提供医院出具的证明。");
//                }
//            }
//        } else {
//            return Result.error("没有获取到id,获取请假信息失败，请联系管理员");
//        }
//        switch (qxlx) {
//            case OaqxjFlowConstant.QXJ_HJ:
//                return Result.ok("婚假可休3个工作日。");
//            case OaqxjFlowConstant.QXJ_CJYH:
//                return Result.ok("一孩产假可休158个自然日。");
//            case OaqxjFlowConstant.QXJ_CJEH:
//                return Result.ok("二孩产假可休168个自然日。");
//            case OaqxjFlowConstant.QXJ_CJSH:
//                return Result.ok("三孩及以上产假可休178个自然日。");
//            case OaqxjFlowConstant.QXJ_CJJ:
//                return Result.ok("");
//            case OaqxjFlowConstant.QXJ_CQJJPHJ:
//                return Result.ok("产前检查陪护假可休5个自然日。");
//            case OaqxjFlowConstant.QXJ_HLJ:
//                return Result.ok("护理假可休25个自然日。");
//            case OaqxjFlowConstant.QXJ_YEJ:
//                return Result.ok("育儿假可休10个自然日。");
//            case OaqxjFlowConstant.QXJ_SSJ:
//                return Result.ok("丧假可休3个工作日。");
//            case OaqxjFlowConstant.QXJ_JZGX:
//                return Result.ok("");
//            default:
//                return Result.error("没有匹配到你所需的请假类型，请联系管理员");
//        }
//    }
//
//
//    /**
//     * @param:
//     * @Description: 手动清空转结年假 全部  如果转结年休假有剩余：  剩余天数 - 转结年休假 = 新的剩余天数
//     * 如果转结年休假没有剩余：就直接赋值为零
//     * @auther: lhb
//     * @date: 2023/9/15 11:33
//     */
//    public Result deletelZjnj(String userids) {
//        List<String> userIdsList = Arrays.asList(userids.split(","));
//        List<YcSysUser> ycSysUsers = ycSysUserService.listByIds(userIdsList);
//        if (CollectionUtils.isNotEmpty(ycSysUsers)) {
//            for (YcSysUser user : ycSysUsers) {
//                if (user.getFnxjzjts() != 0) {
//                    int newsyts = user.getFnxjsyts() - user.getFnxjzjts();
//                    user.setFnxjsyts(newsyts);
//                }
//                user.setFnxjzjts(0);
//                ycSysUserService.updateById(user);
//            }
//        } else {
//            return Result.error("清空转结错误，无法获取用户，请联系管理员");
//        }
//        //       spcyLogService.addLogss("清空转结", "清空转结年假", userids, "", "", "", "");
//        return Result.ok("清空转结成功");
//    }
//
//    /**
//     * @param:
//     * @Description: 转结上一年年休假天数 ,转结上一年休假天数的时候，把当前的数据复制到年休假历史表 并且更新当前工龄 和 当前年的可休年假数
//     * 手动转结
//     * @auther: lhb
//     * @date: 2023/9/15 11:57
//     */
//    public Result zjNxj(String userids) {
//        //先判断一次在手动转结当天是否有未办完的年休假请假数据
//        List<OaQxjsp> list = oaQxjspService.list(new LambdaQueryWrapper<OaQxjsp>().eq(OaQxjsp::getFqjlx, OaqxjFlowConstant.QXJ_NJ)
//                .eq(OaQxjsp::getFlczt, CommonFlowConstant.FLOW_LCZB));
//        if (list.size() > 1) {
//            return Result.error("有未办完的年休假请假流程，请办结完成后在手动转结");
//        }
//
//        //先把现在的数据复制到历史表
//
//        List<String> userIdsList = Arrays.asList(userids.split(","));
//        List<YcSysUser> ycSysUsers = ycSysUserService.listByIds(userIdsList);
//
//        List<OaNxjhistory> nxjhistories = new ArrayList<>();
//        if (CollectionUtils.isNotEmpty(ycSysUsers)) {
//            for (YcSysUser userid : ycSysUsers) {
//                OaNxjhistory oaNxjhistory = new OaNxjhistory();
//                oaNxjhistory.setId(GetUuIdUtils.ReplaceUuId());
//                oaNxjhistory.setFuserName(userid.getRealname());
//                oaNxjhistory.setFuserId(userid.getId());
//                oaNxjhistory.setFzw(userid.getFzw());
//                oaNxjhistory.setFbm(userid.getOrgName());
//                oaNxjhistory.setFgzdw(userid.getFgzdw());
//                oaNxjhistory.setFxb(userid.getSex());
////                oaNxjhistory.setFcjgzsj(DateConversionUtils.DateToString(userid.getFcjgzsj())); //未导入数据之前 暂时不放开
//                oaNxjhistory.setFnxjsyts(userid.getFnxjsyts());
//                oaNxjhistory.setFnxjkxts(userid.getFnxjyxts());
//                oaNxjhistory.setFnxjzjts(userid.getFnxjzjts());
//                oaNxjhistory.setFgl(userid.getFgl());
//                oaNxjhistory.setFnxjyxqjssj(DateConversionUtils.DateToString(new Date()));
//                oaNxjhistory.setFnd(DateConversionUtils.DateToYear(new Date()));
//                nxjhistories.add(oaNxjhistory);
//            }
//            oaNxjhistoryService.saveBatch(nxjhistories);
//
//            //将用户本表的剩余年休假赋值为转结年休假，更新工龄数，并根据更新后的工龄数  重新赋值年休假可休天数和剩余天数 ，将已休天数归零
//            for (YcSysUser updatenxj : ycSysUsers) {
//                int oldsyts = updatenxj.getFnxjsyts(); //更新前的上一年年休假剩余天数 （包含转结天数）
//
//
//                //更新工龄数 几点几年 用来赋值可休年数
//                //工作时间 =当前工作时间- 参加工作时间 -间隔年/月
//                SimpleDateFormat nowdate = new SimpleDateFormat("yyyy-MM");
//                SimpleDateFormat cjgzdate = new SimpleDateFormat("yyyy-MM");
//                Date date = new Date();
//                Date fcjgzsj = updatenxj.getFcjgzsj();
//
//
//                int fjkns = updatenxj.getFjkns();
//
//                List list1 = spcyRsJjrkService.DayCompare(fcjgzsj, date);
//                double year = (int) list1.get(0);
//                double month = (int) list1.get(1);
//
//                //真实工龄数(月) = 当前年月 - 参见工作年月-间隔年月
//                double dqgls = (year * 12 + month) - fjkns;
//
//                //返回2位小数，并且四舍五入
//                DecimalFormat df = new DecimalFormat("######0.0");
//                //真实工龄数
//                String zsgls = df.format(dqgls / 12);
//
//                updatenxj.setFgl(zsgls); //赋值当前转结的时候的工龄数
//                //转为int类型然后比较
//                double gl = Double.parseDouble(zsgls);
//                //根据工龄数查询当前请休假配置并且赋值 新的可休天数
//                List<OaQxjpz> cxjg = oaQxjpzService.list(new LambdaQueryWrapper<OaQxjpz>().le(OaQxjpz::getFzxgls, gl)
//                        .ge(OaQxjpz::getFzdgls, gl));
//                int ts = 0;
//                for (OaQxjpz gljg : cxjg) {
//                    ts = gljg.getFnxjts(); //拿到转结后本年度应休的天数
//                }
//                //更新转结天数 和可休天数 和剩余天数
//                updatenxj.setFnxjzjts(oldsyts);
//                updatenxj.setFnxjyxts(ts + oldsyts);
//                updatenxj.setFnxjsyts(ts + oldsyts);
//            }
//            ycSysUserService.saveOrUpdateBatch(ycSysUsers);
//        } else {
//            return Result.error("获取不到用户数据，请联系管理员");
//        }
//        return Result.ok("更新成功");
//    }

}
